package com.warm.pump.module.skd.dao.gen;

import java.util.List;
import java.util.Map;
import java.util.Date;
import java.math.BigDecimal;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import com.warm.pump.frame.gen.bean.PageBean;
import com.warm.pump.frame.gen.util.TypeCast;
import com.warm.pump.frame.gen.exception.ServiceException;
import com.warm.pump.module.skd.bean.po.gen.ScheduleJob;
import com.warm.pump.module.skd.mapper.gen.ScheduleJobMapper;
import com.warm.pump.module.skd.bean.po.gen.ScheduleJobExample;
@Repository
public class ScheduleJobDao {
	// 日志对象
	private transient Log log = LogFactory.getLog(this.getClass());
	@Autowired
	private ScheduleJobMapper scheduleJobMapper;

	// 增加一个后台ScheduleJob表
	
	public boolean insert(ScheduleJob scheduleJob) {
		try {
			scheduleJobMapper.insert(scheduleJob);
			log.debug("后台ScheduleJob表增加成功");
			return true;
		} catch (Exception e) {
			log.debug("后台ScheduleJob表增加失败");
			throw new ServiceException("后台ScheduleJob表增加失败",e);
		}
	}
	// 增加一个后台ScheduleJob表Selective
	
	public boolean insertSelective(ScheduleJob scheduleJob) {
		try {
			scheduleJobMapper.insertSelective(scheduleJob);
			log.debug("后台ScheduleJob表增加成功");
			return true;
		} catch (Exception e) {
			log.debug("后台ScheduleJob表增加失败");
			throw new ServiceException("后台ScheduleJob表增加失败",e);
		}
	}

	// 删除一个后台ScheduleJob表
	
	public boolean deleteByPrimaryKey(Long id) {
		try{
			scheduleJobMapper.deleteByPrimaryKey(id);
			log.debug("后台ScheduleJob表删除成功");
			return true;
		} catch(Exception e){
			log.debug("后台ScheduleJob表删除失败");
			throw new ServiceException("后台ScheduleJob表删除失败",e);
		}
	}
	// 删除一个后台ScheduleJob表byMap
	
	public boolean deleteByMap(Map scheduleJobMap) {
		try{
			scheduleJobMapper.deleteByExample(createScheduleJobExample(scheduleJobMap,null,null));
			log.debug("后台ScheduleJob根据Map删除成功");
			return true;
		}
		
		catch(Exception e){
			log.debug("后台ScheduleJob根据GroupID删除失败");
			throw new ServiceException("后台ScheduleJob根据object删除失败",e);
		}
	}
	// 修改一个后台ScheduleJob表
	
	public boolean updateByPrimaryKey(ScheduleJob scheduleJob) {
		try{
			scheduleJobMapper.updateByPrimaryKey(scheduleJob);
			log.debug("后台ScheduleJob表修改成功");
			return true;
		}
		
		catch(Exception e){
			log.debug("后台ScheduleJob表修改失败");
			throw new ServiceException("后台ScheduleJob表修改失败",e);
		}
	}
	// 修改一个后台ScheduleJob表Selective
	
	public boolean updateByPrimaryKeySelective(ScheduleJob scheduleJob) {
		try{
			scheduleJobMapper.updateByPrimaryKeySelective(scheduleJob);
			log.debug("后台ScheduleJob表修改成功");
			return true;
		}
		
		catch(Exception e){
			log.debug("后台ScheduleJob表修改失败");
			throw new ServiceException("后台ScheduleJob表修改失败",e);
		}
	}
	// 修改一个后台ScheduleJob表
	
	public boolean updateByMap(ScheduleJob scheduleJob,Map scheduleJobMap) {
		try{
			scheduleJobMapper.updateByExample(scheduleJob,createScheduleJobExample(scheduleJobMap,null,null));
			log.debug("后台批量ScheduleJob表修改成功");
			return true;
		}
		catch(Exception e){
			log.debug("后台批量ScheduleJob表修改失败");
			throw new ServiceException("后台ScheduleJob表批量修改失败",e);
		}
	}
	// 修改一个后台ScheduleJob表Selective
	
	public boolean updateByMapSelective(ScheduleJob scheduleJob,Map scheduleJobMap) {
		try{
			scheduleJobMapper.updateByExampleSelective(scheduleJob,createScheduleJobExample(scheduleJobMap,null,null));
			log.debug("后台批量ScheduleJob表修改成功");
			return true;
		}
		catch(Exception e){
			log.debug("后台批量ScheduleJob表修改失败");
			throw new ServiceException("后台ScheduleJob表批量修改失败",e);
		}
	}

	// 查询一个后台ScheduleJob表
	
	public ScheduleJob selectByPrimaryKey(Long id) {
		return scheduleJobMapper.selectByPrimaryKey(id);
	}
	
	// 查询一个后台ScheduleJob表-根据map
	
	public ScheduleJob selectByMap(Map scheduleJobMap) {
		List<ScheduleJob> list = getListByMap(scheduleJobMap);
		if(list==null||list.isEmpty()){
			return null;
		}else{
			return list.get(0);
		}
	}

	////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 查询所有后台ScheduleJob表
	
	public List<ScheduleJob> getListByMap(Map scheduleJobMap) {
		
		return scheduleJobMapper.selectByExample(createScheduleJobExample(scheduleJobMap,null,null));
	}

	//统计后台ScheduleJob表数量
	
	public int countTotalByMap(Map scheduleJobMap) {
		
		return scheduleJobMapper.countByExample(createScheduleJobExample(scheduleJobMap,null,null));
	}

	
	public List<ScheduleJob> getListByMapPage(Map scheduleJobMap, int limitStart,
			int limitOffset) {
		
		return scheduleJobMapper.selectByExample(createScheduleJobExample(scheduleJobMap,limitStart,limitOffset));
	}
	
	
	public PageBean getPageBeanByMap(Map scheduleJobMap,int pageNo,int pageSize) {
		Integer count = countTotalByMap(scheduleJobMap);
		PageBean pageBean = new PageBean();
		pageBean.setCount(count);
		pageBean.setPageNo(pageNo);
		pageBean.setPageSize(pageSize);
		int limitStart = pageBean.getStartNo();
		int limitOffset = pageSize;
		pageBean.setData(scheduleJobMapper.selectByExample(createScheduleJobExample(scheduleJobMap,limitStart,limitOffset)));
		return pageBean;
	}
		
	private ScheduleJobExample createScheduleJobExample(Map scheduleJobMap,Integer limitStart,Integer limitOffset){
			ScheduleJobExample scheduleJobEx = new ScheduleJobExample();
			ScheduleJobExample.Criteria c = scheduleJobEx.createCriteria();
				Long id_null = TypeCast.getLong(scheduleJobMap.get("id_null"));
				Long id_notNull = TypeCast.getLong(scheduleJobMap.get("id_notNull"));
				Long id = TypeCast.getLong(scheduleJobMap.get("id"));
				Long id_not = TypeCast.getLong(scheduleJobMap.get("id_not"));
				Long id_greater = TypeCast.getLong(scheduleJobMap.get("id_greater"));
				Long id_greaterEqual = TypeCast.getLong(scheduleJobMap.get("id_greaterEqual"));
				Long id_less = TypeCast.getLong(scheduleJobMap.get("id_less"));
				Long id_lessEqual = TypeCast.getLong(scheduleJobMap.get("id_lessEqual"));
				List<Long> id_in = TypeCast.getLongList(scheduleJobMap.get("id_in"));
				List<Long> id_notIn = TypeCast.getLongList(scheduleJobMap.get("id_notIn"));
				Long id_between1 = TypeCast.getLong(scheduleJobMap.get("id_between1"));
				Long id_between2 = TypeCast.getLong(scheduleJobMap.get("id_between2"));
				Long id_notBetween1 = TypeCast.getLong(scheduleJobMap.get("id_notBetween1"));
				Long id_notBetween2 = TypeCast.getLong(scheduleJobMap.get("id_notBetween2"));
				
				if(id_null != null){
					c.andIdIsNull();
				}
				if(id_notNull != null){
					c.andIdIsNotNull();
				}
				if(id != null){
					c.andIdEqualTo(id);
				}
				if(id_not != null){
					c.andIdNotEqualTo(id_not);
				}
				if(id_greater != null){
					c.andIdGreaterThan(id_greater);
				}
				if(id_greaterEqual != null){
					c.andIdGreaterThanOrEqualTo(id_greaterEqual);
				}
				if(id_less != null){
					c.andIdLessThan(id_less);
				}
				if(id_lessEqual != null){
					c.andIdLessThanOrEqualTo(id_lessEqual);
				}
				if(id_in != null){
					c.andIdIn(id_in);
				}
				if(id_notIn != null){
					c.andIdNotIn(id_notIn);
				}
				if(id_between1 != null){
					c.andIdBetween(id_between1,id_between2);
				}
				if(id_notBetween1 != null){
					c.andIdNotBetween(id_notBetween1,id_notBetween2);
				}
				String jobName_null = TypeCast.getString(scheduleJobMap.get("jobName_null"));
				String jobName_notNull = TypeCast.getString(scheduleJobMap.get("jobName_notNull"));
				String jobName = TypeCast.getString(scheduleJobMap.get("jobName"));
				String jobName_not = TypeCast.getString(scheduleJobMap.get("jobName_not"));
				String jobName_greater = TypeCast.getString(scheduleJobMap.get("jobName_greater"));
				String jobName_greaterEqual = TypeCast.getString(scheduleJobMap.get("jobName_greaterEqual"));
				String jobName_less = TypeCast.getString(scheduleJobMap.get("jobName_less"));
				String jobName_lessEqual = TypeCast.getString(scheduleJobMap.get("jobName_lessEqual"));
				String jobName_like = TypeCast.getString(scheduleJobMap.get("jobName_like"));
				String jobName_notLike = TypeCast.getString(scheduleJobMap.get("jobName_notLike"));
				List<String> jobName_in = TypeCast.getStringList(scheduleJobMap.get("jobName_in"));
				List<String> jobName_notIn = TypeCast.getStringList(scheduleJobMap.get("jobName_notIn"));
				String jobName_between1 = TypeCast.getString(scheduleJobMap.get("jobName_between1"));
				String jobName_between2 = TypeCast.getString(scheduleJobMap.get("jobName_between2"));
				String jobName_notBetween1 = TypeCast.getString(scheduleJobMap.get("jobName_notBetween1"));
				String jobName_notBetween2 = TypeCast.getString(scheduleJobMap.get("jobName_notBetween2"));
				
				if(jobName_null != null){
					c.andJobNameIsNull();
				}
				if(jobName_notNull != null){
					c.andJobNameIsNotNull();
				}
				if(jobName != null){
					c.andJobNameEqualTo(jobName);
				}
				if(jobName_not != null){
					c.andJobNameNotEqualTo(jobName_not);
				}
				if(jobName_greater != null){
					c.andJobNameGreaterThan(jobName_greater);
				}
				if(jobName_greaterEqual != null){
					c.andJobNameGreaterThanOrEqualTo(jobName_greaterEqual);
				}
				if(jobName_less != null){
					c.andJobNameLessThan(jobName_less);
				}
				if(jobName_lessEqual != null){
					c.andJobNameLessThanOrEqualTo(jobName_lessEqual);
				}
				if(jobName_like != null){
					c.andJobNameLike(jobName_like);
				}
				if(jobName_notLike != null){
					c.andJobNameNotLike(jobName_notLike);
				}
				if(jobName_in != null){
					c.andJobNameIn(jobName_in);
				}
				if(jobName_notIn != null){
					c.andJobNameNotIn(jobName_notIn);
				}
				if(jobName_between1 != null){
					c.andJobNameBetween(jobName_between1,jobName_between2);
				}
				if(jobName_notBetween1 != null){
					c.andJobNameNotBetween(jobName_notBetween1,jobName_notBetween2);
				}
				Integer status_null = TypeCast.getInteger(scheduleJobMap.get("status_null"));
				Integer status_notNull = TypeCast.getInteger(scheduleJobMap.get("status_notNull"));
				Integer status = TypeCast.getInteger(scheduleJobMap.get("status"));
				Integer status_not = TypeCast.getInteger(scheduleJobMap.get("status_not"));
				Integer status_greater = TypeCast.getInteger(scheduleJobMap.get("status_greater"));
				Integer status_greaterEqual = TypeCast.getInteger(scheduleJobMap.get("status_greaterEqual"));
				Integer status_less = TypeCast.getInteger(scheduleJobMap.get("status_less"));
				Integer status_lessEqual = TypeCast.getInteger(scheduleJobMap.get("status_lessEqual"));
				List<Integer> status_in = TypeCast.getIntegerList(scheduleJobMap.get("status_in"));
				List<Integer> status_notIn = TypeCast.getIntegerList(scheduleJobMap.get("status_notIn"));
				Integer status_between1 = TypeCast.getInteger(scheduleJobMap.get("status_between1"));
				Integer status_between2 = TypeCast.getInteger(scheduleJobMap.get("status_between2"));
				Integer status_notBetween1 = TypeCast.getInteger(scheduleJobMap.get("status_notBetween1"));
				Integer status_notBetween2 = TypeCast.getInteger(scheduleJobMap.get("status_notBetween2"));
				
				if(status_null != null){
					c.andStatusIsNull();
				}
				if(status_notNull != null){
					c.andStatusIsNotNull();
				}
				if(status != null){
					c.andStatusEqualTo(status);
				}
				if(status_not != null){
					c.andStatusNotEqualTo(status_not);
				}
				if(status_greater != null){
					c.andStatusGreaterThan(status_greater);
				}
				if(status_greaterEqual != null){
					c.andStatusGreaterThanOrEqualTo(status_greaterEqual);
				}
				if(status_less != null){
					c.andStatusLessThan(status_less);
				}
				if(status_lessEqual != null){
					c.andStatusLessThanOrEqualTo(status_lessEqual);
				}
				if(status_in != null){
					c.andStatusIn(status_in);
				}
				if(status_notIn != null){
					c.andStatusNotIn(status_notIn);
				}
				if(status_between1 != null){
					c.andStatusBetween(status_between1,status_between2);
				}
				if(status_notBetween1 != null){
					c.andStatusNotBetween(status_notBetween1,status_notBetween2);
				}
				String cronExpression_null = TypeCast.getString(scheduleJobMap.get("cronExpression_null"));
				String cronExpression_notNull = TypeCast.getString(scheduleJobMap.get("cronExpression_notNull"));
				String cronExpression = TypeCast.getString(scheduleJobMap.get("cronExpression"));
				String cronExpression_not = TypeCast.getString(scheduleJobMap.get("cronExpression_not"));
				String cronExpression_greater = TypeCast.getString(scheduleJobMap.get("cronExpression_greater"));
				String cronExpression_greaterEqual = TypeCast.getString(scheduleJobMap.get("cronExpression_greaterEqual"));
				String cronExpression_less = TypeCast.getString(scheduleJobMap.get("cronExpression_less"));
				String cronExpression_lessEqual = TypeCast.getString(scheduleJobMap.get("cronExpression_lessEqual"));
				String cronExpression_like = TypeCast.getString(scheduleJobMap.get("cronExpression_like"));
				String cronExpression_notLike = TypeCast.getString(scheduleJobMap.get("cronExpression_notLike"));
				List<String> cronExpression_in = TypeCast.getStringList(scheduleJobMap.get("cronExpression_in"));
				List<String> cronExpression_notIn = TypeCast.getStringList(scheduleJobMap.get("cronExpression_notIn"));
				String cronExpression_between1 = TypeCast.getString(scheduleJobMap.get("cronExpression_between1"));
				String cronExpression_between2 = TypeCast.getString(scheduleJobMap.get("cronExpression_between2"));
				String cronExpression_notBetween1 = TypeCast.getString(scheduleJobMap.get("cronExpression_notBetween1"));
				String cronExpression_notBetween2 = TypeCast.getString(scheduleJobMap.get("cronExpression_notBetween2"));
				
				if(cronExpression_null != null){
					c.andCronExpressionIsNull();
				}
				if(cronExpression_notNull != null){
					c.andCronExpressionIsNotNull();
				}
				if(cronExpression != null){
					c.andCronExpressionEqualTo(cronExpression);
				}
				if(cronExpression_not != null){
					c.andCronExpressionNotEqualTo(cronExpression_not);
				}
				if(cronExpression_greater != null){
					c.andCronExpressionGreaterThan(cronExpression_greater);
				}
				if(cronExpression_greaterEqual != null){
					c.andCronExpressionGreaterThanOrEqualTo(cronExpression_greaterEqual);
				}
				if(cronExpression_less != null){
					c.andCronExpressionLessThan(cronExpression_less);
				}
				if(cronExpression_lessEqual != null){
					c.andCronExpressionLessThanOrEqualTo(cronExpression_lessEqual);
				}
				if(cronExpression_like != null){
					c.andCronExpressionLike(cronExpression_like);
				}
				if(cronExpression_notLike != null){
					c.andCronExpressionNotLike(cronExpression_notLike);
				}
				if(cronExpression_in != null){
					c.andCronExpressionIn(cronExpression_in);
				}
				if(cronExpression_notIn != null){
					c.andCronExpressionNotIn(cronExpression_notIn);
				}
				if(cronExpression_between1 != null){
					c.andCronExpressionBetween(cronExpression_between1,cronExpression_between2);
				}
				if(cronExpression_notBetween1 != null){
					c.andCronExpressionNotBetween(cronExpression_notBetween1,cronExpression_notBetween2);
				}
				String remark_null = TypeCast.getString(scheduleJobMap.get("remark_null"));
				String remark_notNull = TypeCast.getString(scheduleJobMap.get("remark_notNull"));
				String remark = TypeCast.getString(scheduleJobMap.get("remark"));
				String remark_not = TypeCast.getString(scheduleJobMap.get("remark_not"));
				String remark_greater = TypeCast.getString(scheduleJobMap.get("remark_greater"));
				String remark_greaterEqual = TypeCast.getString(scheduleJobMap.get("remark_greaterEqual"));
				String remark_less = TypeCast.getString(scheduleJobMap.get("remark_less"));
				String remark_lessEqual = TypeCast.getString(scheduleJobMap.get("remark_lessEqual"));
				String remark_like = TypeCast.getString(scheduleJobMap.get("remark_like"));
				String remark_notLike = TypeCast.getString(scheduleJobMap.get("remark_notLike"));
				List<String> remark_in = TypeCast.getStringList(scheduleJobMap.get("remark_in"));
				List<String> remark_notIn = TypeCast.getStringList(scheduleJobMap.get("remark_notIn"));
				String remark_between1 = TypeCast.getString(scheduleJobMap.get("remark_between1"));
				String remark_between2 = TypeCast.getString(scheduleJobMap.get("remark_between2"));
				String remark_notBetween1 = TypeCast.getString(scheduleJobMap.get("remark_notBetween1"));
				String remark_notBetween2 = TypeCast.getString(scheduleJobMap.get("remark_notBetween2"));
				
				if(remark_null != null){
					c.andRemarkIsNull();
				}
				if(remark_notNull != null){
					c.andRemarkIsNotNull();
				}
				if(remark != null){
					c.andRemarkEqualTo(remark);
				}
				if(remark_not != null){
					c.andRemarkNotEqualTo(remark_not);
				}
				if(remark_greater != null){
					c.andRemarkGreaterThan(remark_greater);
				}
				if(remark_greaterEqual != null){
					c.andRemarkGreaterThanOrEqualTo(remark_greaterEqual);
				}
				if(remark_less != null){
					c.andRemarkLessThan(remark_less);
				}
				if(remark_lessEqual != null){
					c.andRemarkLessThanOrEqualTo(remark_lessEqual);
				}
				if(remark_like != null){
					c.andRemarkLike(remark_like);
				}
				if(remark_notLike != null){
					c.andRemarkNotLike(remark_notLike);
				}
				if(remark_in != null){
					c.andRemarkIn(remark_in);
				}
				if(remark_notIn != null){
					c.andRemarkNotIn(remark_notIn);
				}
				if(remark_between1 != null){
					c.andRemarkBetween(remark_between1,remark_between2);
				}
				if(remark_notBetween1 != null){
					c.andRemarkNotBetween(remark_notBetween1,remark_notBetween2);
				}
				Date createTime_null = TypeCast.getDate(scheduleJobMap.get("createTime_null"));
				Date createTime_notNull = TypeCast.getDate(scheduleJobMap.get("createTime_notNull"));
				Date createTime = TypeCast.getDate(scheduleJobMap.get("createTime"));
				Date createTime_not = TypeCast.getDate(scheduleJobMap.get("createTime_not"));
				Date createTime_greater = TypeCast.getDate(scheduleJobMap.get("createTime_greater"));
				Date createTime_greaterEqual = TypeCast.getDate(scheduleJobMap.get("createTime_greaterEqual"));
				Date createTime_less = TypeCast.getDate(scheduleJobMap.get("createTime_less"));
				Date createTime_lessEqual = TypeCast.getDate(scheduleJobMap.get("createTime_lessEqual"));
				List<Date> createTime_in = TypeCast.getDateList(scheduleJobMap.get("createTime_in"));
				List<Date> createTime_notIn = TypeCast.getDateList(scheduleJobMap.get("createTime_notIn"));
				Date createTime_between1 = TypeCast.getDate(scheduleJobMap.get("createTime_between1"));
				Date createTime_between2 = TypeCast.getDate(scheduleJobMap.get("createTime_between2"));
				Date createTime_notBetween1 = TypeCast.getDate(scheduleJobMap.get("createTime_notBetween1"));
				Date createTime_notBetween2 = TypeCast.getDate(scheduleJobMap.get("createTime_notBetween2"));
				
				if(createTime_null != null){
					c.andCreateTimeIsNull();
				}
				if(createTime_notNull != null){
					c.andCreateTimeIsNotNull();
				}
				if(createTime != null){
					c.andCreateTimeEqualTo(createTime);
				}
				if(createTime_not != null){
					c.andCreateTimeNotEqualTo(createTime_not);
				}
				if(createTime_greater != null){
					c.andCreateTimeGreaterThan(createTime_greater);
				}
				if(createTime_greaterEqual != null){
					c.andCreateTimeGreaterThanOrEqualTo(createTime_greaterEqual);
				}
				if(createTime_less != null){
					c.andCreateTimeLessThan(createTime_less);
				}
				if(createTime_lessEqual != null){
					c.andCreateTimeLessThanOrEqualTo(createTime_lessEqual);
				}
				if(createTime_in != null){
					c.andCreateTimeIn(createTime_in);
				}
				if(createTime_notIn != null){
					c.andCreateTimeNotIn(createTime_notIn);
				}
				if(createTime_between1 != null){
					c.andCreateTimeBetween(createTime_between1,createTime_between2);
				}
				if(createTime_notBetween1 != null){
					c.andCreateTimeNotBetween(createTime_notBetween1,createTime_notBetween2);
				}
				Date updateTime_null = TypeCast.getDate(scheduleJobMap.get("updateTime_null"));
				Date updateTime_notNull = TypeCast.getDate(scheduleJobMap.get("updateTime_notNull"));
				Date updateTime = TypeCast.getDate(scheduleJobMap.get("updateTime"));
				Date updateTime_not = TypeCast.getDate(scheduleJobMap.get("updateTime_not"));
				Date updateTime_greater = TypeCast.getDate(scheduleJobMap.get("updateTime_greater"));
				Date updateTime_greaterEqual = TypeCast.getDate(scheduleJobMap.get("updateTime_greaterEqual"));
				Date updateTime_less = TypeCast.getDate(scheduleJobMap.get("updateTime_less"));
				Date updateTime_lessEqual = TypeCast.getDate(scheduleJobMap.get("updateTime_lessEqual"));
				List<Date> updateTime_in = TypeCast.getDateList(scheduleJobMap.get("updateTime_in"));
				List<Date> updateTime_notIn = TypeCast.getDateList(scheduleJobMap.get("updateTime_notIn"));
				Date updateTime_between1 = TypeCast.getDate(scheduleJobMap.get("updateTime_between1"));
				Date updateTime_between2 = TypeCast.getDate(scheduleJobMap.get("updateTime_between2"));
				Date updateTime_notBetween1 = TypeCast.getDate(scheduleJobMap.get("updateTime_notBetween1"));
				Date updateTime_notBetween2 = TypeCast.getDate(scheduleJobMap.get("updateTime_notBetween2"));
				
				if(updateTime_null != null){
					c.andUpdateTimeIsNull();
				}
				if(updateTime_notNull != null){
					c.andUpdateTimeIsNotNull();
				}
				if(updateTime != null){
					c.andUpdateTimeEqualTo(updateTime);
				}
				if(updateTime_not != null){
					c.andUpdateTimeNotEqualTo(updateTime_not);
				}
				if(updateTime_greater != null){
					c.andUpdateTimeGreaterThan(updateTime_greater);
				}
				if(updateTime_greaterEqual != null){
					c.andUpdateTimeGreaterThanOrEqualTo(updateTime_greaterEqual);
				}
				if(updateTime_less != null){
					c.andUpdateTimeLessThan(updateTime_less);
				}
				if(updateTime_lessEqual != null){
					c.andUpdateTimeLessThanOrEqualTo(updateTime_lessEqual);
				}
				if(updateTime_in != null){
					c.andUpdateTimeIn(updateTime_in);
				}
				if(updateTime_notIn != null){
					c.andUpdateTimeNotIn(updateTime_notIn);
				}
				if(updateTime_between1 != null){
					c.andUpdateTimeBetween(updateTime_between1,updateTime_between2);
				}
				if(updateTime_notBetween1 != null){
					c.andUpdateTimeNotBetween(updateTime_notBetween1,updateTime_notBetween2);
				}
				String misfireInformIds_null = TypeCast.getString(scheduleJobMap.get("misfireInformIds_null"));
				String misfireInformIds_notNull = TypeCast.getString(scheduleJobMap.get("misfireInformIds_notNull"));
				String misfireInformIds = TypeCast.getString(scheduleJobMap.get("misfireInformIds"));
				String misfireInformIds_not = TypeCast.getString(scheduleJobMap.get("misfireInformIds_not"));
				String misfireInformIds_greater = TypeCast.getString(scheduleJobMap.get("misfireInformIds_greater"));
				String misfireInformIds_greaterEqual = TypeCast.getString(scheduleJobMap.get("misfireInformIds_greaterEqual"));
				String misfireInformIds_less = TypeCast.getString(scheduleJobMap.get("misfireInformIds_less"));
				String misfireInformIds_lessEqual = TypeCast.getString(scheduleJobMap.get("misfireInformIds_lessEqual"));
				String misfireInformIds_like = TypeCast.getString(scheduleJobMap.get("misfireInformIds_like"));
				String misfireInformIds_notLike = TypeCast.getString(scheduleJobMap.get("misfireInformIds_notLike"));
				List<String> misfireInformIds_in = TypeCast.getStringList(scheduleJobMap.get("misfireInformIds_in"));
				List<String> misfireInformIds_notIn = TypeCast.getStringList(scheduleJobMap.get("misfireInformIds_notIn"));
				String misfireInformIds_between1 = TypeCast.getString(scheduleJobMap.get("misfireInformIds_between1"));
				String misfireInformIds_between2 = TypeCast.getString(scheduleJobMap.get("misfireInformIds_between2"));
				String misfireInformIds_notBetween1 = TypeCast.getString(scheduleJobMap.get("misfireInformIds_notBetween1"));
				String misfireInformIds_notBetween2 = TypeCast.getString(scheduleJobMap.get("misfireInformIds_notBetween2"));
				
				if(misfireInformIds_null != null){
					c.andMisfireInformIdsIsNull();
				}
				if(misfireInformIds_notNull != null){
					c.andMisfireInformIdsIsNotNull();
				}
				if(misfireInformIds != null){
					c.andMisfireInformIdsEqualTo(misfireInformIds);
				}
				if(misfireInformIds_not != null){
					c.andMisfireInformIdsNotEqualTo(misfireInformIds_not);
				}
				if(misfireInformIds_greater != null){
					c.andMisfireInformIdsGreaterThan(misfireInformIds_greater);
				}
				if(misfireInformIds_greaterEqual != null){
					c.andMisfireInformIdsGreaterThanOrEqualTo(misfireInformIds_greaterEqual);
				}
				if(misfireInformIds_less != null){
					c.andMisfireInformIdsLessThan(misfireInformIds_less);
				}
				if(misfireInformIds_lessEqual != null){
					c.andMisfireInformIdsLessThanOrEqualTo(misfireInformIds_lessEqual);
				}
				if(misfireInformIds_like != null){
					c.andMisfireInformIdsLike(misfireInformIds_like);
				}
				if(misfireInformIds_notLike != null){
					c.andMisfireInformIdsNotLike(misfireInformIds_notLike);
				}
				if(misfireInformIds_in != null){
					c.andMisfireInformIdsIn(misfireInformIds_in);
				}
				if(misfireInformIds_notIn != null){
					c.andMisfireInformIdsNotIn(misfireInformIds_notIn);
				}
				if(misfireInformIds_between1 != null){
					c.andMisfireInformIdsBetween(misfireInformIds_between1,misfireInformIds_between2);
				}
				if(misfireInformIds_notBetween1 != null){
					c.andMisfireInformIdsNotBetween(misfireInformIds_notBetween1,misfireInformIds_notBetween2);
				}
			if(scheduleJobMap.get("orderBy")!=null){
				scheduleJobEx.setOrderByClause((String)scheduleJobMap.get("orderBy"));
			}
			if(limitStart != null && limitOffset != null){
				scheduleJobEx.setLimitStart(limitStart);
				scheduleJobEx.setLimitOffset(limitOffset);
			}
			
			return scheduleJobEx;
	}
}
